package com.atao.baokede.controller;

import com.alipay.api.domain.OrderDetail;
import com.atao.baokede.pojo.*;
import com.atao.baokede.pojo.dto.ItemDto;
import com.atao.baokede.pojo.dto.MerchantDto;
import com.atao.baokede.pojo.dto.MerchantDto2;
import com.atao.baokede.pojo.vo.MerchantVo;
import com.atao.baokede.service.ItemService;
import com.atao.baokede.service.MerchantService;
import com.atao.baokede.utils.JwtUtil;
import com.atao.baokede.utils.ThreadLocalUtil;
import jakarta.validation.Valid;
import jakarta.validation.constraints.Pattern;
import org.hibernate.validator.constraints.URL;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;

import static com.atao.baokede.constant.MerchantConstant.STATUS_FREEZE;

/**
 * 商家相关接口
 * 商家注册只用于新用户
 */
@RestController
@RequestMapping("/merchant")
public class MerchantController {
    @Autowired
    private MerchantService merchantService;
    @Autowired
    private ItemService itemService;

    /**
     * 商家注册
     *
     * @param merchantDto 商家信息
     * @param userId      用户id
     * @return 无
     */
    @PostMapping("/register")
    public Result register(@Valid @RequestBody MerchantDto merchantDto, @RequestParam Long userId) {
        //根据商家名称查询商家
        Merchant m1 = merchantService.findByName(merchantDto.getName());
        //根据用户id查询商家
        Merchant m2 = merchantService.findByUserId(userId);
        if (m1 != null) {
            //占用名称，注册失败
            return Result.error("商家名称已占用");
        } else if (m2 != null) {
            return Result.error("用户已注册商家");
        } else {
            //符合一切注册条件
            merchantService.register(merchantDto, userId);
            return Result.success();
        }
    }

    /**
     * 商家注册
     *
     * @param name     商家名称
     * @param password 商家密码
     * @param userId   用户id
     * @return jwt令牌
     */
    @PostMapping("/login")
    public Result login(@RequestParam String name,
                        @RequestParam String password,
                        @RequestParam Long userId) {
        //查询商户
        Merchant m = merchantService.findByName(name);

        if (m == null) {
            //商户不存在
            return Result.error("商户不存在");
        } else if (!Objects.equals(userId, m.getCreater())) {
            //如果当前商户不是由创建人账号登录，则报错
            return Result.error("请由创建人账号登录该商户");
        } else if (m.getStatus() == STATUS_FREEZE) {
            return Result.error("该商户已被禁用，请联系管理员");
        } else {
            //商户存在
            if (m.getPassword().equals(password)) {
                //密码正确，登录
                //生成token,并将商户id存到token中
                Map<String, Object> merchantClaims = new HashMap<>();
                merchantClaims.put("type", "merchant");
                merchantClaims.put("id", m.getId());
                String token = JwtUtil.genToken(merchantClaims);
                return Result.success(token);
            } else {
                return Result.error("密码错误");
            }
        }
    }

    /**
     * 获取当前已登录商家的详细信息
     *
     * @return 商家服务，获得商家的信息 merchantService.getMerchantInfo()
     */
    @GetMapping("/merchantInfo")
    public Result<MerchantVo> merchantInfo() {
        return Result.success(merchantService.getMerchantInfo());
    }

    /**
     * 更新已登录商户的基本信息(除头像和密码)
     *
     * @param merchantDto2 商家
     * @return 无
     */
    @PutMapping("/update")
    public Result update(@RequestBody MerchantDto2 merchantDto2) {
        merchantService.update(merchantDto2);
        return Result.success();
    }

    /**
     * 更新已登录商户的头像
     *
     * @param avatarUrl logo地址
     * @return 无
     */
    @PatchMapping("/updateLogo")
    public Result updateAvatar(@RequestParam @URL String avatarUrl) throws Exception {
        merchantService.updateLogo(avatarUrl);
        return Result.success();
    }

    /**
     * 更新已登录商户的密码
     *
     * @param newPwd 新密码
     * @param rePwd  确认新密码
     * @return 无
     */
    @PatchMapping("updatePwd")
    public Result updatePwd(@RequestParam @Pattern(regexp = "^\\S{5,16}$") String newPwd,
                            @RequestParam @Pattern(regexp = "^\\S{5,16}$") String rePwd) {
        //检测两次输入的密码是否一致
        if (!newPwd.equals(rePwd)) {
            return Result.error("两次输入的密码不一致");
        }
        merchantService.updatePwd(newPwd);
        return Result.success();
    }

    /**
     * 根据商户id分页查询商品
     *
     * @param pageNum  页码
     * @param pageSize 每页记录数
     * @return 商品列表
     */
    @GetMapping("/findItemsByMerchantId")
    public Result<PageBean<Item>> findItemsByMerchantId(
            @RequestParam Integer pageNum,
            @RequestParam Integer pageSize
    ) {
        PageBean<Item> pb = itemService.findItemsByMerchantId(pageNum, pageSize);
        return Result.success(pb);
    }

    /**
     * 商户添加商品
     *
     * @param itemDto 商品信息
     * @return 添加结果
     */
    @PostMapping("/addItem")
    public Result addItem(@RequestBody ItemDto itemDto) throws IOException {
        int categoryLength = itemDto.getCategory().length();
        if (categoryLength > 10 || categoryLength < 1) {
            return Result.error("商品类别长度必须在1-10之间");
        }
        ;
        itemService.addItem(itemDto);
        return Result.success();
    }

    /**
     * 商家下架商品
     *
     * @param itemId 商品id
     * @return 禁用结果
     */
    @PutMapping("/disableItem")
    public Result disableItem(@RequestParam Long itemId) throws IOException {
        itemService.disableItem(itemId);
        return Result.success();
    }

    /**
     * 商家修改商品信息（修改完商品状态自动变为待审核）
     *
     * @param item 商品信息（id，name，price，stock，image，category，brand，spec）
     * @return 无
     */
    @PutMapping("/updateItem")
    public Result updateItem(@RequestBody Item item) throws IOException {
        itemService.updateItem(item);
        return Result.success();
    }

    /**
     * 商家删除商品
     *
     * @param itemId 商品id
     */
    @DeleteMapping("/deleteItem")
    public Result deleteItem(@RequestParam Long itemId) throws IOException {
        itemService.deleteItem(itemId);
        return Result.success();
    }

    /**
     * 商家批量删除商品
     *
     * @param itemIds 商品id列表
     */
    @DeleteMapping("/deleteItems")
    public Result deleteItems(@RequestBody List<Long> itemIds) throws IOException {
        itemService.deleteItems(itemIds);
        return Result.success();
    }

    /**
     * 商家批量下架商品
     *
     * @param itemIds 商品id列表
     */
    @PutMapping("/disableItems")
    public Result disableItems(@RequestParam List<Long> itemIds) throws IOException {
        itemService.disableItems(itemIds);
        return Result.success();
    }

    /**
     * 商家上架商品（商品状态自动变为待审核）
     *
     * @param itemId 商品id
     */
    @PutMapping("/enableItem")
    public Result enableItem(@RequestParam Long itemId) {
        itemService.enableItem(itemId);
        return Result.success();
    }

    /**
     * 批量上架商品
     *
     * @param itemIds 商品id集合
     */
    @PutMapping("/enableItems")
    public Result enableItems(@RequestBody List<Long> itemIds) {
        itemService.enableItems(itemIds);
        return Result.success();
    }

    /**
     * 分页查询各种状态的订单
     *
     * @param status 订单状态 0-未支付,1-未发货,2-已发货，3-已到达，4-已收货，5-申请退款，6-拒绝退款，7-已退款（必须）
     * @param order_id 订单id（非必须）
     * @param name 商品名称（非必须）
     * @param pageNum 页码
     * @param pageSize 每页数量
     * @return 订单列表
     */
    @GetMapping("/findOrders")
    public Result<PageBean<MerchantOrder>> findOrders(
            @RequestParam Integer status,
            @RequestParam(required = false) String order_id,
            @RequestParam(required = false) String name,
            @RequestParam Integer pageNum,
            @RequestParam Integer pageSize
    ){
        PageBean<MerchantOrder> pb=merchantService.findOrders(status,order_id,name,pageNum,pageSize);
        return Result.success(pb);
    }

}

